home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / idlelib / HyperParser.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  7KB  |  177 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''
  5. HyperParser
  6. ===========
  7. This module defines the HyperParser class, which provides advanced parsing
  8. abilities for the ParenMatch and other extensions.
  9. The HyperParser uses PyParser. PyParser is intended mostly to give information
  10. on the proper indentation of code. HyperParser gives some information on the
  11. structure of code, used by extensions to help the user.
  12. '''
  13. import string
  14. import keyword
  15. import PyParse
  16.  
  17. class HyperParser:
  18.     
  19.     def __init__(self, editwin, index):
  20.         '''Initialize the HyperParser to analyze the surroundings of the given
  21.         index.
  22.         '''
  23.         self.editwin = editwin
  24.         self.text = text = editwin.text
  25.         parser = PyParse.Parser(editwin.indentwidth, editwin.tabwidth)
  26.         
  27.         def index2line(index):
  28.             return int(float(index))
  29.  
  30.         lno = index2line(text.index(index))
  31.         if not editwin.context_use_ps1:
  32.             for context in editwin.num_context_lines:
  33.                 startat = max(lno - context, 1)
  34.                 startatindex = `startat` + '.0'
  35.                 stopatindex = '%d.end' % lno
  36.                 parser.set_str(text.get(startatindex, stopatindex) + ' \n')
  37.                 bod = parser.find_good_parse_start(editwin._build_char_in_string_func(startatindex))
  38.                 if bod is not None or startat == 1:
  39.                     break
  40.                     continue
  41.             
  42.             if not bod:
  43.                 pass
  44.             parser.set_lo(0)
  45.         else:
  46.             r = text.tag_prevrange('console', index)
  47.             if r:
  48.                 startatindex = r[1]
  49.             else:
  50.                 startatindex = '1.0'
  51.             stopatindex = '%d.end' % lno
  52.             parser.set_str(text.get(startatindex, stopatindex) + ' \n')
  53.             parser.set_lo(0)
  54.         self.rawtext = parser.str[:-2]
  55.         self.stopatindex = stopatindex
  56.         self.bracketing = parser.get_last_stmt_bracketing()
  57.         self.isopener = [ self.bracketing[i][1] > self.bracketing[i - 1][1] for i in range(len(self.bracketing)) ]
  58.         self.set_index(index)
  59.  
  60.     
  61.     def set_index(self, index):
  62.         '''Set the index to which the functions relate. Note that it must be
  63.         in the same statement.
  64.         '''
  65.         indexinrawtext = len(self.rawtext) - len(self.text.get(index, self.stopatindex))
  66.         if indexinrawtext < 0:
  67.             raise ValueError('The index given is before the analyzed statement')
  68.         
  69.         self.indexinrawtext = indexinrawtext
  70.         self.indexbracket = 0
  71.         while self.indexbracket < len(self.bracketing) - 1 and self.bracketing[self.indexbracket + 1][0] < self.indexinrawtext:
  72.             self.indexbracket += 1
  73.             continue
  74.             self
  75.         if self.indexbracket < len(self.bracketing) - 1 and self.bracketing[self.indexbracket + 1][0] == self.indexinrawtext and not self.isopener[self.indexbracket + 1]:
  76.             self.indexbracket += 1
  77.         
  78.  
  79.     
  80.     def is_in_string(self):
  81.         '''Is the index given to the HyperParser is in a string?'''
  82.         if self.isopener[self.indexbracket]:
  83.             pass
  84.         return self.rawtext[self.bracketing[self.indexbracket][0]] in ('"', "'")
  85.  
  86.     
  87.     def is_in_code(self):
  88.         '''Is the index given to the HyperParser is in a normal code?'''
  89.         if not not self.isopener[self.indexbracket]:
  90.             pass
  91.         return self.rawtext[self.bracketing[self.indexbracket][0]] not in ('#', '"', "'")
  92.  
  93.     
  94.     def get_surrounding_brackets(self, openers = '([{', mustclose = False):
  95.         '''If the index given to the HyperParser is surrounded by a bracket
  96.         defined in openers (or at least has one before it), return the
  97.         indices of the opening bracket and the closing bracket (or the
  98.         end of line, whichever comes first).
  99.         If it is not surrounded by brackets, or the end of line comes before
  100.         the closing bracket and mustclose is True, returns None.
  101.         '''
  102.         bracketinglevel = self.bracketing[self.indexbracket][1]
  103.         before = self.indexbracket
  104.         while not self.isopener[before] and self.rawtext[self.bracketing[before][0]] not in openers or self.bracketing[before][1] > bracketinglevel:
  105.             before -= 1
  106.             if before < 0:
  107.                 return None
  108.             
  109.             bracketinglevel = min(bracketinglevel, self.bracketing[before][1])
  110.         after = self.indexbracket + 1
  111.         while after < len(self.bracketing) and self.bracketing[after][1] >= bracketinglevel:
  112.             after += 1
  113.         beforeindex = self.text.index('%s-%dc' % (self.stopatindex, len(self.rawtext) - self.bracketing[before][0]))
  114.         if after >= len(self.bracketing) or self.bracketing[after][0] > len(self.rawtext):
  115.             if mustclose:
  116.                 return None
  117.             
  118.             afterindex = self.stopatindex
  119.         else:
  120.             afterindex = self.text.index('%s-%dc' % (self.stopatindex, len(self.rawtext) - self.bracketing[after][0] - 1))
  121.         return (beforeindex, afterindex)
  122.  
  123.     _whitespace_chars = ' \t\n\\'
  124.     _id_chars = string.ascii_letters + string.digits + '_'
  125.     _id_first_chars = string.ascii_letters + '_'
  126.     
  127.     def _eat_identifier(self, str, limit, pos):
  128.         i = pos
  129.         while i > limit and str[i - 1] in self._id_chars:
  130.             i -= 1
  131.         if i < pos:
  132.             if str[i] not in self._id_first_chars or keyword.iskeyword(str[i:pos]):
  133.                 i = pos
  134.             
  135.         return pos - i
  136.  
  137.     
  138.     def get_expression(self):
  139.         '''Return a string with the Python expression which ends at the given
  140.         index, which is empty if there is no real one.
  141.         '''
  142.         if not self.is_in_code():
  143.             raise ValueError('get_expression should only be called if index is inside a code.')
  144.         
  145.         rawtext = self.rawtext
  146.         bracketing = self.bracketing
  147.         brck_index = self.indexbracket
  148.         brck_limit = bracketing[brck_index][0]
  149.         pos = self.indexinrawtext
  150.         last_identifier_pos = pos
  151.         postdot_phase = True
  152.         while None:
  153.             while pos > brck_limit and rawtext[pos - 1] in self._whitespace_chars:
  154.                 pos -= 1
  155.                 continue
  156.                 if not postdot_phase and pos > brck_limit and rawtext[pos - 1] == '.':
  157.                     pos -= 1
  158.                     postdot_phase = True
  159.                     continue
  160.             if pos == brck_limit and brck_index > 0 and rawtext[bracketing[brck_index - 1][0]] == '#':
  161.                 brck_index -= 2
  162.                 brck_limit = bracketing[brck_index][0]
  163.                 pos = bracketing[brck_index + 1][0]
  164.                 continue
  165.             break
  166.             continue
  167.             if not postdot_phase:
  168.                 break
  169.             
  170.             ret = self._eat_identifier(rawtext, brck_limit, pos)
  171.             None if ret else rawtext[pos] in '(['
  172.             break
  173.             continue
  174.             return rawtext[last_identifier_pos:self.indexinrawtext]
  175.  
  176.  
  177.